backend/src/main/java/org/cryptomator/hub/api/GroupDto.java (1)

10-13: Add validation for memberCount parameter.

The constructor should validate that memberCount is not negative to ensure data integrity.

 GroupDto(@JsonProperty("id") String id, @JsonProperty("name") String name, @JsonProperty("memberCount") int memberCount) {
     super(id, Type.GROUP, name, null);
+    if (memberCount < 0) {
+        throw new IllegalArgumentException("Member count cannot be negative");
+    }
     this.memberCount = memberCount;
 }

backend/src/main/java/org/cryptomator/hub/api/AuthorityDto.java (1)

38-44: Consider moving member count logic to service layer.

The DTO layer should focus on data transformation. Consider moving the member count retrieval logic to a dedicated service class to maintain better separation of concerns.

backend/src/main/java/org/cryptomator/hub/entities/Group.java (2)

23-25: Avoid repository injection in entity classes.

Injecting repositories into entity classes breaks the JPA entity model and could cause serialization issues. Consider moving this logic to a service layer.

-@Inject
-transient Repository groupRepo;

-public int getMemberCount() {
-    return groupRepo.countMembers(this.getId());
-}

Also applies to: 34-36

---

40-45: Optimize member count query for large groups.

Using SIZE on a collection could be inefficient for large groups. Consider using a COUNT query instead.

 public int countMembers(String groupId) {
     return getEntityManager()
-            .createQuery("SELECT SIZE(g.members) FROM Group g WHERE g.id = :groupId", Integer.class)
+            .createQuery("SELECT COUNT(m) FROM Group g JOIN g.members m WHERE g.id = :groupId", Long.class)
             .setParameter("groupId", groupId)
-            .getSingleResult();
+            .getSingleResult().intValue();
 }

backend/src/main/java/org/cryptomator/hub/api/GroupsResource.java (1)

5-5: Remove unused imports.

The following imports are not used in the code:

• jakarta.ws.rs.core.Response
• java.util.HashMap
• java.util.Map

Also applies to: 17-18

backend/src/main/java/org/cryptomator/hub/api/AuthorityResource.java (1)

56-64: Consider adding null check for the authority parameter.

While the implementation is good, it could benefit from defensive programming.

 private AuthorityDto convertToDto(Authority a) {
+    if (a == null) {
+        throw new IllegalArgumentException("authority cannot be null");
+    }
     if (a instanceof User u) {
         return UserDto.justPublicInfo(u);
     } else if (a instanceof Group g) {
         int memberCount = (int) userRepo.getEffectiveGroupUsers(g.getId()).count();
         return new GroupDto(g.getId(), g.getName(), memberCount);
     } else {
         throw new IllegalStateException("authority is not of type user or group");
     }
 }

frontend/src/components/SearchInputGroup.vue (1)

31-33: Consider adding aria-label for screen readers.

The member count display could benefit from improved accessibility.

-<span v-if="'memberCount' in item && item.memberCount !== undefined" class="ml-auto text-xs text-gray-500 italic">
+<span v-if="'memberCount' in item && item.memberCount !== undefined" 
+      class="ml-auto text-xs text-gray-500 italic"
+      :aria-label="`${item.memberCount} ${t('vaultDetails.sharedWith.members')}`">
   {{ item.memberCount }} {{ t('vaultDetails.sharedWith.members') }}
 </span>

frontend/src/common/backend.ts (1)

90-96: Consider adding retry logic for the member count API call.

The getMemberCount implementation could be more resilient to temporary network issues.

 class GroupService {
   public async getMemberCount(groupId: string): Promise<number> {
+    const maxRetries = 3;
+    const retryDelay = 1000; // 1 second
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
         return axiosAuth.get<UserDto[]>(`/groups/${groupId}/effective-members`)
           .then(response => response.data.length)
           .catch(() => 0);
+      } catch (error) {
+        if (attempt === maxRetries) return 0;
+        await new Promise(resolve => setTimeout(resolve, retryDelay));
+      }
+    }
+    return 0;
   }
 }

frontend/src/components/VaultDetails.vue (1)

498-518: Consider implementing debouncing for the search functionality.

The search functionality could benefit from debouncing to prevent excessive API calls.

+import { debounce } from '../common/util';
+
+const debouncedSearch = debounce(async (query: string) => {
+  const results = await backend.authorities.search(query);
+  return results;
+}, 300);
+
 async function searchAuthority(query: string): Promise<(AuthorityDto & { memberCount?: number })[]> {
-  const results = await backend.authorities.search(query);
+  const results = await debouncedSearch(query);
   const filtered = results.filter(authority => !members.value.has(authority.id));

   const enhanced = await Promise.all(
     filtered.map(async authority => {
       if (authority.type === "GROUP") {
         try {
           const count = await backend.groups.getMemberCount(authority.id);
           return { ...authority, memberCount: count };
         } catch (error) {
           return { ...authority, memberCount: 0 };
         }
       }
       return authority;
     })
   );
   return enhanced.sort((a, b) => a.name.localeCompare(b.name));
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro